package com.gkzf.ai.module.crm.util.assembly;

import com.alibaba.fastjson.JSONObject;
import com.gkzf.ai.module.crm.controller.admin.creditReport.vo.admittancecondition.OverdueRecordVo;
import com.gkzf.ai.module.crm.controller.admin.creditReport.vo.creditreportdetails.CreditReportDetailsSaveReqVO;
import com.gkzf.ai.module.crm.dal.dataobject.creditReport.CreditReportBasicDO;
import com.gkzf.ai.module.crm.dal.dataobject.creditReport.UserCreditReportAdmittanceConditionDO;
import com.gkzf.ai.module.crm.service.creditReport.CreditReportAdmittanceConditionServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;
import java.math.BigDecimal;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.regex.Pattern;

import static com.gkzf.ai.module.crm.util.assembly.AssemblyCreditReportDetails.*;
import static com.gkzf.ai.module.crm.util.assembly.AssemblyCreditReportDetails.KEY_BASIC;

@Slf4j
public class AssembleUtils {

    /**
     * 安全地从 JSONObject 获取 String 值，处理 null 和 trim。
     * @param jsonObject 源 JSONObject
     * @param fieldName 字段名
     * @return 获取到的 String 值，如果 key 不存在、值为 null 或发生异常，返回空字符串。
     */
    public static String getStringValue(JSONObject jsonObject, String fieldName) {
        try {
            if (!jsonObject.containsKey(fieldName)) {
                return ""; // key 不存在时返回空字符串
            }
            // getString 方法在 key 不存在或值为 null 时会返回 null
            String value = jsonObject.getString(fieldName);
            if (Objects.equals(value.trim(),"null")){
                return "";
            }
            log.info("解析字符串字段名称：{},  转换后值：{},  原始对象：{}", fieldName, value, jsonObject.toJSONString());
            return value.trim().replaceAll("[,.]", ""); // 如果为 null，返回空字符串
        } catch (Exception e) {
            // 理论上 getString 和 trim 不太会抛出意料之外的异常，但为了安全还是捕获
            log.error("征信报告解析错误：处理字段 '{}' 失败，原始对象: {}", fieldName, jsonObject.toJSONString(), e);
            return ""; // 发生异常时返回空字符串
        }
    }

    /**
     * 安全地从 JSONObject 获取 String 值，处理 null 和 trim。
     * @param jsonObject 源 JSONObject
     * @param fieldName 字段名
     * @return 获取到的 String 值，如果 key 不存在、值为 null 或发生异常，返回空字符串。
     */
    public static Integer getStringInteger(JSONObject jsonObject, String fieldName) {
        try {
            if (!jsonObject.containsKey(fieldName)) {
                return 0; // key 不存在时返回空字符串
            }
            // getString 方法在 key 不存在或值为 null 时会返回 null
            String value = jsonObject.getString(fieldName);
            if (Objects.equals(value.trim(),"null")){
                return 0;
            }
            if (Objects.equals(value.trim(),"--")){
                return 0;
            }
            if (!StringUtils.isNotBlank(value.trim())){
                return 0;
            }
            log.info("解析数字字段名称：{},  转换后值：{},  原始对象：{}", fieldName, value, jsonObject.toJSONString());
            return toIntegerSafely(value.trim(), 0); // 如果为 null，返回 0
        } catch (Exception e) {
            // 理论上 getString 和 trim 不太会抛出意料之外的异常，但为了安全还是捕获
            log.error("征信报告解析错误：处理字段 '{}' 失败，原始对象: {}", fieldName, jsonObject.toJSONString(), e);
            return 0; // 发生异常时返回空字符串
        }
    }

    /**
     * 安全地从 JSONObject 获取 BigDecimal 值，处理 null, trim, convertMoney 和数字格式错误。
     * @param jsonObject 源 JSONObject
     * @param fieldName 字段名
     * @return 获取到的 BigDecimal 值，如果 key 不存在、值为 null、转换失败或发生异常，返回 BigDecimal.ZERO。
     */
    public static BigDecimal getBigDecimalValue(JSONObject jsonObject, String fieldName) {
        try {
            String valueStr = jsonObject.getString(fieldName);

            // 检查原始值是否为 null 或空
            if (valueStr == null
                    || valueStr.trim().isEmpty()
                    || Objects.equals(valueStr.trim(),"--")
                    || Objects.equals(valueStr.trim(),"null")) {
                return BigDecimal.ZERO; // null 或空字符串返回 BigDecimal.ZERO
            }

            // 使用 convertMoney 转换
            String convertedMoneyStr = convertMoney(valueStr.trim());

            // 检查 convertMoney 返回结果
            if (convertedMoneyStr.trim().isEmpty()) {
                log.warn("征信报告解析警告：字段 '{}' 的 convertMoney 方法返回空字符串。原始值: '{}', 对象: {}",
                        fieldName, valueStr, jsonObject.toJSONString());
                return BigDecimal.ZERO;
            }


            // 尝试转换为 BigDecimal
            log.info("解析金额类型字段名称：{},  转换后值：{},  原始对象：{}", fieldName, convertedMoneyStr, jsonObject.toJSONString());
            return new BigDecimal(convertedMoneyStr);

        } catch (NumberFormatException e) {
            // 专门捕获数字格式错误
            log.error("征信报告解析错误：解析金额字段 '{}' 失败，值 '{}' 不是有效数字。原始对象: {}",
                    fieldName, jsonObject.getString(fieldName), jsonObject.toJSONString(), e);
            return BigDecimal.ZERO; // 转换失败返回 BigDecimal.ZERO
        } catch (Exception e) {
            // 捕获其他潜在异常（如 convertMoney 内部异常等）
            log.error("征信报告解析错误：处理金额字段 '{}' 时发生未知错误。原始值: '{}', 对象: {}",
                    fieldName, jsonObject.getString(fieldName), jsonObject.toJSONString(), e);
            return BigDecimal.ZERO; // 发生异常返回 BigDecimal.ZERO
        }
    }

    // 假设 convertMoney 方法存在于此类或可访问的地方
    // private static String convertMoney(String moneyStr) { ... }
    // 例如：
    private static String convertMoney(String moneyStr) {
        if (moneyStr == null) {
            return null;
        }
        // 示例实现：移除逗号和货币符号，只保留数字和小数点
        return moneyStr.replace(",", "").replace("￥", "").replace("$", "").trim();
        // 注意：实际的 convertMoney 方法可能需要处理更复杂的格式
    }

    // 尝试转换为整数（支持浮点字符串自动取整）
    private static Integer toIntegerSafely(String str, Integer defaultValue) {
        if (str == null || str.trim().isEmpty()) {
            return defaultValue;
        }

        try {
            // 如果已经是整数格式，直接转换
            if (isInteger(str)) {
                return Integer.parseInt(str);
            }

            // 否则尝试解析为 double 再取整
            double d = Double.parseDouble(str);
            return (int) d; // 截断取整，也可以用 Math.round(d)

        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    // 判断是否是整数字符串
    private static boolean isInteger(String str) {
        return str != null && Pattern.matches("^-?\\d+$", str);
    }

    // 判断是否是整数字符串
    public static boolean isString(String str) {
        return str != null && Pattern.matches("[\\u4E00-\\u9FA5]+", str);
    }


    public static void main(String[] args) throws IOException {
        Map<String,Object> createReqVO = new HashMap<>();
        createReqVO.put(KEY_MODEL_LOAN, Files.readString(Paths.get("/Users/mac/Documents/2.txt")));
        createReqVO.put(KEY_MODEL_CREDIT_CARD, Files.readString(Paths.get("/Users/mac/Documents/3.txt")));
        createReqVO.put(KEY_QUERY_RECORD, Files.readString(Paths.get("/Users/mac/Documents/4.txt")));
        createReqVO.put(KEY_BASIC, Files.readString(Paths.get("/Users/mac/Documents/1.txt")));

        CreditReportAdmittanceConditionServiceImpl service = new CreditReportAdmittanceConditionServiceImpl();
        // 解析 查询记录json
        Map<String, List<OverdueRecordVo>> overdueMap = new LinkedHashMap<>();
        // 解析 查询记录json
        UserCreditReportAdmittanceConditionDO admittanceConditionDO = new UserCreditReportAdmittanceConditionDO();
        CreditReportDetailsSaveReqVO detailsDO = new CreditReportDetailsSaveReqVO();
        CreditReportBasicDO basicDO = new CreditReportBasicDO();
        service.calculateOverdueStatistics(createReqVO,overdueMap,detailsDO,basicDO,admittanceConditionDO);

        log.info(overdueMap.toString());

    }

}
